{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Matplotlib created a temporary config/cache directory at /tmp/matplotlib-7edc_3tr because the default path (/home/hello/.config/matplotlib) is not a writable directory; it is highly recommended to set the MPLCONFIGDIR environment variable to a writable directory, in particular to speed up the import of Matplotlib and to better support multiprocessing.\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import time\n",
    "import pickle\n",
    "import importlib\n",
    "import numpy as np\n",
    "import torch\n",
    "import mmengine\n",
    "import matplotlib.pyplot as plt\n",
    "os.chdir('../')\n",
    "from model.model import TrajectoryModel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset_path = './data/'\n",
    "dataset_name = 'CODA'\n",
    "hp_config = 'configs/coda.py'\n",
    "lr_scaling = False\n",
    "num_workers = 8\n",
    "gpu = 0\n",
    "data_scaling = [1.9, 0.4]\n",
    "checkpoint = './checkpoint/'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TrajectoryModel(\n",
       "  (embedding): Linear(in_features=80, out_features=128, bias=True)\n",
       "  (mode_encoder): Encoder(\n",
       "    (layers): ModuleList(\n",
       "      (0-1): 2 x TransformerBlock(\n",
       "        (attn): MultihHeadAttention(\n",
       "          (w_key): Linear(in_features=128, out_features=128, bias=True)\n",
       "          (w_query): Linear(in_features=128, out_features=128, bias=True)\n",
       "          (w_value): Linear(in_features=128, out_features=128, bias=True)\n",
       "          (fc_out): Linear(in_features=128, out_features=128, bias=True)\n",
       "          (dropout): Dropout(p=0.1, inplace=False)\n",
       "        )\n",
       "        (norm1): LayerNorm()\n",
       "        (norm2): LayerNorm()\n",
       "        (feed_forward): FeedForwardLayer(\n",
       "          (w1): Linear(in_features=128, out_features=256, bias=True)\n",
       "          (w2): Linear(in_features=256, out_features=128, bias=True)\n",
       "        )\n",
       "        (dropout): Dropout(p=0.1, inplace=False)\n",
       "      )\n",
       "    )\n",
       "    (dropout): Dropout(p=0.1, inplace=False)\n",
       "  )\n",
       "  (cls_head): Linear(in_features=128, out_features=1, bias=True)\n",
       "  (nei_embedding): Linear(in_features=32, out_features=128, bias=True)\n",
       "  (social_decoder): Decoder(\n",
       "    (layers): ModuleList(\n",
       "      (0): TransformerBlock(\n",
       "        (attn): MultihHeadAttention(\n",
       "          (w_key): Sequential(\n",
       "            (0): Linear(in_features=128, out_features=128, bias=True)\n",
       "            (1): ReLU()\n",
       "            (2): Linear(in_features=128, out_features=128, bias=True)\n",
       "          )\n",
       "          (w_query): Sequential(\n",
       "            (0): Linear(in_features=128, out_features=128, bias=True)\n",
       "            (1): ReLU()\n",
       "            (2): Linear(in_features=128, out_features=128, bias=True)\n",
       "          )\n",
       "          (w_value): Linear(in_features=128, out_features=128, bias=True)\n",
       "          (fc_out): Linear(in_features=128, out_features=128, bias=True)\n",
       "          (dropout): Dropout(p=0.1, inplace=False)\n",
       "        )\n",
       "        (norm1): LayerNorm()\n",
       "        (norm2): LayerNorm()\n",
       "        (feed_forward): FeedForwardLayer(\n",
       "          (w1): Linear(in_features=128, out_features=256, bias=True)\n",
       "          (w2): Linear(in_features=256, out_features=128, bias=True)\n",
       "        )\n",
       "        (dropout): Dropout(p=0.1, inplace=False)\n",
       "      )\n",
       "    )\n",
       "    (dropout): Dropout(p=0.1, inplace=False)\n",
       "  )\n",
       "  (reg_head): Linear(in_features=128, out_features=48, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "track_results = mmengine.load('./data/CODA/coda_track_results.pkl')\n",
    "\n",
    "spec = importlib.util.spec_from_file_location(\"hp_config\", hp_config)\n",
    "hp_config = importlib.util.module_from_spec(spec)\n",
    "spec.loader.exec_module(hp_config)\n",
    "obs_len = hp_config.OB_HORIZON\n",
    "pred_len = hp_config.PRED_HORIZON\n",
    "\n",
    "motion_modes_file = dataset_path + dataset_name + '_motion_modes.pkl'\n",
    "f = open(dataset_path + dataset_name + '_motion_modes.pkl', 'rb+')\n",
    "motion_modes = pickle.load(f)\n",
    "f.close()\n",
    "motion_modes = torch.tensor(motion_modes, dtype=torch.float32).cuda()\n",
    "\n",
    "model = TrajectoryModel(in_size=2, obs_len=obs_len, pred_len=pred_len, embed_size=hp_config.model_hidden_dim, \n",
    "            enc_num_layers=2, int_num_layers_list=[1,1], heads=4, forward_expansion=2)\n",
    "model.load_state_dict(torch.load(checkpoint + dataset_name + '/best.pth'))\n",
    "model = model.cuda()\n",
    "model.eval()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "pedestrian_label = 1\n",
    "all_tracks = []\n",
    "for sequence_results in track_results:\n",
    "    \n",
    "    tracks = {}\n",
    "    frame_len = len(sequence_results['data_list'][pedestrian_label])\n",
    "    for i, frame_result in enumerate(sequence_results['data_list'][pedestrian_label]):\n",
    "        track_bboxes = frame_result['track_bboxes']\n",
    "        track_ids = frame_result['track_ids']\n",
    "        track_states = frame_result['track_states']\n",
    "        for j in range(len(track_bboxes)):\n",
    "            tokens = track_states[j].split('_')\n",
    "            if tokens[0] == 'birth':\n",
    "                valid =  True\n",
    "            elif len(tokens) < 3:\n",
    "                valid =  False\n",
    "            elif tokens[0] == 'alive' and int(tokens[1]) == 1:\n",
    "                valid =  True\n",
    "            if tracks.get(track_ids[j]) is None:\n",
    "                tracks[track_ids[j]] = [[1e9, 1e9]] * (i + obs_len - 2)\n",
    "            if valid:\n",
    "                tracks[track_ids[j]].append(track_bboxes[j][:2].tolist())\n",
    "            else:\n",
    "                tracks[track_ids[j]].append([1e9, 1e9])\n",
    "    \n",
    "    for i in tracks.keys():\n",
    "        lost_frame = -1\n",
    "        for j in range(obs_len - 1, len(tracks[i])):\n",
    "            if tracks[i][j][0] > 1e8 and tracks[i][j-1][0] < 1e8:\n",
    "                lost_frame = j\n",
    "            elif lost_frame != -1:\n",
    "                # 对于丢失的轨迹，进行线性插值\n",
    "                start = tracks[i][lost_frame-1]\n",
    "                end = tracks[i][j]\n",
    "                for l in range(lost_frame, j):\n",
    "                    tracks[i][l][0] = start[0] + (end[0] - start[0]) / (j - lost_frame) * (l - lost_frame)\n",
    "                    tracks[i][l][1] = start[1] + (end[1] - start[1]) / (j - lost_frame) * (l - lost_frame)\n",
    "                lost_frame = -1\n",
    "        if len(tracks[i]) < frame_len + obs_len - 2:\n",
    "            tracks[i].extend([[1e9, 1e9]] * (frame_len + obs_len - 2 - len(tracks[i])))\n",
    "            \n",
    "    all_tracks.append(tracks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def visual(obs, preds, scores, ids):\n",
    "    # obs [B T_obs 2]\n",
    "    # preds [B num_k T_pred 2]\n",
    "    # scores [B num_k]\n",
    "    # ids [B]\n",
    "    plt.clf()\n",
    "    for i in range(obs.shape[0]):\n",
    "        ob = obs[i].cpu().numpy()\n",
    "        pred = preds[i].cpu().numpy()\n",
    "        score = scores[i].cpu().numpy()\n",
    "        ob_x = ob[:, 0]\n",
    "        ob_y = ob[:, 1]\n",
    "        plt.plot(ob_x, ob_y, marker='o', color='green')\n",
    "        plt.text(ob_x[-1], ob_y[-1], str(ids[i]),  ha='center')\n",
    "       \n",
    "        for j in range(pred.shape[0]):\n",
    "            pred_x = np.concatenate((ob_x[-1:], pred[j][:, 0]))\n",
    "            pred_y = np.concatenate((ob_y[-1:], pred[j][:, 1]))\n",
    "            plt.plot(pred_x, pred_y, ls='-.', lw=0.5, color='red')\n",
    "            plt.scatter(pred_x[-1], pred_y[-1], marker='*', color='red', s=100)\n",
    "            plt.text(pred_x[-1], pred_y[-1], str(\"%.2f\" % score[j]),  ha='center')\n",
    "        \n",
    "    plt.tight_layout()\n",
    "    save_path = './fig/' + dataset_name\n",
    "    if not os.path.exists(save_path):\n",
    "        os.makedirs(save_path)\n",
    "    plt.savefig(save_path + '/' + str(time.time()) + '.png')\n",
    "    return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def data_preprocess(tracks):\n",
    "\n",
    "    track_len, frame_len = tracks.shape[:2]\n",
    "    data_inputs = []\n",
    "    for j in range(obs_len - 1, frame_len):\n",
    "        obs = []\n",
    "        neis = []\n",
    "        n_neighbors = []\n",
    "        neis_mask = []\n",
    "        refs = []\n",
    "        rot_mats = []\n",
    "        ids = []\n",
    "        now_tracks = tracks[:, j-(obs_len-1):j+1]\n",
    "        for i in range(track_len):\n",
    "            if now_tracks[i][-1][0] < 1e8 and now_tracks[i][-2][0] < 1e8:\n",
    "                # 获取当前轨迹的观测值ob和邻居nei\n",
    "                ob = now_tracks[i].copy()\n",
    "                for k in range(obs_len - 2, -1, -1):\n",
    "                    if ob[k][0] > 1e8:\n",
    "                        ob[k] = ob[k+1]\n",
    "                nei = now_tracks[np.arange(track_len) != i]\n",
    "                dist_mask = nei[:, :, 0] > 1e8\n",
    "                dist = np.linalg.norm(ob.reshape(1, obs_len, 2) - nei, axis=-1)\n",
    "                dist[dist_mask] = 1e9\n",
    "                dist = np.min(dist, axis=-1)\n",
    "                nei = nei[dist < hp_config.dist_threshold]\n",
    "\n",
    "                # 平移变换\n",
    "                refs.append(ob[-1])\n",
    "                nei = nei - ob[-1]\n",
    "                ob = ob - ob[-1]\n",
    "\n",
    "                # 旋转变换\n",
    "                angle = np.arctan2(ob[0][1], ob[0][0])\n",
    "                rot_mat = np.array([[np.cos(angle), -np.sin(angle)], \n",
    "                                    [np.sin(angle), np.cos(angle)]], dtype=np.float32)\n",
    "                ob = np.matmul(ob, rot_mat)\n",
    "                if nei.shape[0] != 0:\n",
    "                    nei = np.matmul(nei, rot_mat)\n",
    "\n",
    "                obs.append(ob)\n",
    "                neis.append(nei)\n",
    "                n_neighbors.append(nei.shape[0])\n",
    "                rot_mats.append(rot_mat)\n",
    "                ids.append(track_ids[i])\n",
    "\n",
    "        # 对于邻居数不足的轨迹，进行padding\n",
    "        max_neighbors = max(n_neighbors)\n",
    "        if max_neighbors == 0:\n",
    "            max_neighbors = 1\n",
    "        neis_pad = []\n",
    "        for neighbor, n in zip(neis, n_neighbors):\n",
    "            neis_pad.append(np.pad(neighbor, ((0, max_neighbors-n), (0, 0),  (0, 0)), \"constant\"))\n",
    "            mask = np.zeros((max_neighbors, max_neighbors))\n",
    "            mask[:n, :n] = 1\n",
    "            neis_mask.append(mask)\n",
    "    \n",
    "        obs = torch.tensor(np.stack(obs), dtype=torch.float32).cuda()\n",
    "        neis = torch.tensor(np.stack(neis_pad), dtype=torch.float32).cuda()\n",
    "        neis_mask = torch.tensor(np.stack(neis_mask), dtype=torch.float32).cuda()\n",
    "        refs = torch.tensor(np.stack(refs), dtype=torch.float32).cuda()\n",
    "        rot_mats = torch.tensor(np.stack(rot_mats), dtype=torch.float32).cuda()\n",
    "        data_inputs.append((obs, neis, neis_mask, refs, rot_mats, ids))\n",
    "\n",
    "    return data_inputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "199 528\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "all_traj_pre_results = []\n",
    "for i in range(len(all_tracks)):\n",
    "    track_ids = list(all_tracks[i].keys())\n",
    "    tracks = np.array([all_tracks[i][k] for k in track_ids], dtype=np.float32)\n",
    "    print(i)\n",
    "    data_inputs = data_preprocess(tracks)\n",
    "    num_traj = 0\n",
    "    traj_pre_results = []\n",
    "    with torch.no_grad():\n",
    "        for j in range(len(data_inputs)):\n",
    "            obs, neis, neis_mask, refs, rot_mats, ids = data_inputs[j]\n",
    "            num_traj += obs.shape[0]\n",
    "            start = time.time()\n",
    "            preds, scores = model(obs, neis, motion_modes, neis_mask, None, test=True, num_k=3)\n",
    "            scores = torch.nn.functional.softmax(scores, dim=-1)\n",
    "            preds = preds.reshape(preds.shape[0], preds.shape[1], pred_len, 2)\n",
    "            rot_mats_T = rot_mats.transpose(1, 2)\n",
    "            obs_ori = torch.matmul(obs, rot_mats_T) + refs.unsqueeze(1)\n",
    "            preds_ori = torch.matmul(preds, rot_mats_T.unsqueeze(1)) + refs.unsqueeze(1).unsqueeze(2)\n",
    "            visual(obs_ori, preds_ori, scores, ids)\n",
    "            traj_pre_results.append({'track_ids': ids, 'obs':obs_ori.cpu().numpy(), 'preds': preds_ori.cpu().numpy(), 'scores': scores.cpu().numpy()})\n",
    "            if j == 100:\n",
    "                break\n",
    "    print(len(data_inputs), num_traj)\n",
    "    all_traj_pre_results.append({'token': track_results[i]['token'], 'data_list': traj_pre_results})\n",
    "    break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[[[ 0.7957, -1.3587],\n",
       "          [ 0.7298, -1.3163],\n",
       "          [ 0.6718, -1.2864],\n",
       "          [ 0.6187, -1.2589],\n",
       "          [ 0.4851, -1.2853],\n",
       "          [ 0.4070, -1.2712],\n",
       "          [ 0.3280, -1.2570],\n",
       "          [ 0.4364, -0.9971]]],\n",
       "\n",
       "\n",
       "        [[[-0.6839,  0.7264],\n",
       "          [-0.7635,  0.6877],\n",
       "          [-0.8444,  0.6483],\n",
       "          [-0.9186,  0.6122],\n",
       "          [-0.9203,  0.5609],\n",
       "          [-0.9415,  0.5248],\n",
       "          [-0.9840,  0.4498],\n",
       "          [-1.0149,  0.3932]]],\n",
       "\n",
       "\n",
       "        [[[ 0.0000,  0.0000],\n",
       "          [ 0.0000,  0.0000],\n",
       "          [ 0.0000,  0.0000],\n",
       "          [ 0.0000,  0.0000],\n",
       "          [ 0.0000,  0.0000],\n",
       "          [ 0.0000,  0.0000],\n",
       "          [ 0.0000,  0.0000],\n",
       "          [ 0.0000,  0.0000]]]], device='cuda:0')"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "neis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "199"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "obs_ori, preds_ori, scores, ids"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[9.9998e-01, 1.4315e-05, 8.6078e-06, 6.0097e-07, 2.3276e-07],\n",
       "        [9.9998e-01, 1.4317e-05, 8.6086e-06, 6.0103e-07, 2.3277e-07],\n",
       "        [9.9998e-01, 1.4520e-05, 8.7606e-06, 6.1525e-07, 2.4160e-07]],\n",
       "       device='cuda:0')"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "python310",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
